package com.socialsoftware.repository;

import android.app.Application;
import android.util.Log;

import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;

import com.google.gson.reflect.TypeToken;
import com.socialsoftware.api.ApiError;
import com.socialsoftware.api.ApiService;
import com.socialsoftware.model.AppDatabase;
import com.socialsoftware.model.Contact;
import com.socialsoftware.model.ContactDao;
import com.socialsoftware.util.SessionManager;

import org.json.JSONObject;

import java.io.IOException;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * Repository class that abstracts access to different data sources.
 * This provides a clean API for the ViewModel to interact with data.
 */
public class ContactRepository {
    
    private static final String TAG = "ContactRepository";
    
    private ContactDao contactDao;
    private LiveData<List<Contact>> allContacts;
    private LiveData<List<Contact>> starredContacts;
    private LiveData<List<Contact>> specialContacts;
    private ApiService apiService;
    private final MutableLiveData<Boolean> isLoadingLiveData = new MutableLiveData<>(false);
    private final MutableLiveData<String> errorMessageLiveData = new MutableLiveData<>("");
    private final Application application;
    
    public ContactRepository(Application application) {
        this.application = application;
        try {
            AppDatabase db = AppDatabase.getDatabase(application);
            contactDao = db.contactDao();
            allContacts = contactDao.getAllContacts();
            starredContacts = contactDao.getStarredContacts();
            specialContacts = contactDao.getSpecialContacts();
        } catch (Exception e) {
            Log.e(TAG, "Error initializing database: " + e.getMessage(), e);
            errorMessageLiveData.postValue("数据库初始化错误: " + e.getMessage());
        }
        
        // 初始化API服务
        SessionManager sessionManager = SessionManager.getInstance(application);
        apiService = new ApiService(sessionManager);
    }
    
    // Room executes all queries on a separate thread.
    // Observed LiveData will notify the observer when the data has changed.
    public LiveData<List<Contact>> getAllContacts() {
        return allContacts;
    }
    
    public LiveData<List<Contact>> getStarredContacts() {
        return starredContacts;
    }
    
    public LiveData<List<Contact>> getSpecialContacts() {
        return specialContacts;
    }
    
    public LiveData<Boolean> getIsLoading() {
        return isLoadingLiveData;
    }
    
    public LiveData<String> getErrorMessage() {
        return errorMessageLiveData;
    }
    
    public LiveData<List<Contact>> searchContacts(String query) {
        if (contactDao == null) {
            reinitializeDatabase();
            return new MutableLiveData<>(new ArrayList<>());
        }
        return contactDao.searchContacts(query);
    }
    
    public LiveData<Contact> getContactById(String id) {
        if (contactDao == null) {
            reinitializeDatabase();
            return new MutableLiveData<>(null);
        }
        return contactDao.getContactById(id);
    }
    
    /**
     * 通过用户名获取联系人
     */
    public LiveData<Contact> getContactByName(String name) {
        if (contactDao == null) {
            reinitializeDatabase();
            return new MutableLiveData<>(null);
        }
        return contactDao.getContactByName(name);
    }
    
    /**
     * 重新初始化数据库连接
     */
    private void reinitializeDatabase() {
        try {
            AppDatabase db = AppDatabase.getDatabase(application);
            contactDao = db.contactDao();
            allContacts = contactDao.getAllContacts();
            starredContacts = contactDao.getStarredContacts();
            specialContacts = contactDao.getSpecialContacts();
        } catch (Exception e) {
            Log.e(TAG, "Error reinitializing database: " + e.getMessage(), e);
        }
    }
    
    // You must call these methods on a non-UI thread or your app will throw an exception.
    // Room ensures that you don't do any long-running operations on the main thread.
    public void insert(Contact contact) {
        AppDatabase.databaseWriteExecutor.execute(() -> {
            try {
                if (contactDao == null) {
                    reinitializeDatabase();
                    if (contactDao == null) {
                        return;
                    }
                }
                contactDao.insert(contact);
            } catch (Exception e) {
                Log.e(TAG, "Error inserting contact: " + e.getMessage(), e);
            }
        });
    }
    
    public void update(Contact contact) {
        AppDatabase.databaseWriteExecutor.execute(() -> {
            try {
                if (contactDao == null) {
                    reinitializeDatabase();
                    if (contactDao == null) {
                        return;
                    }
                }
                contactDao.update(contact);
            } catch (Exception e) {
                Log.e(TAG, "Error updating contact: " + e.getMessage(), e);
            }
        });
    }
    
    public void delete(Contact contact) {
        AppDatabase.databaseWriteExecutor.execute(() -> {
            try {
                if (contactDao == null) {
                    reinitializeDatabase();
                    if (contactDao == null) {
                        return;
                    }
                }
                contactDao.delete(contact);
            } catch (Exception e) {
                Log.e(TAG, "Error deleting contact: " + e.getMessage(), e);
            }
        });
    }
    
    public void insertAll(List<Contact> contacts) {
        AppDatabase.databaseWriteExecutor.execute(() -> {
            try {
                if (contactDao == null) {
                    reinitializeDatabase();
                    if (contactDao == null) {
                        return;
                    }
                }
                contactDao.insertAll(contacts);
            } catch (Exception e) {
                Log.e(TAG, "Error inserting all contacts: " + e.getMessage(), e);
            }
        });
    }
    
    /**
     * 从服务器获取联系人数据并保存到本地数据库
     * 如果服务器请求失败（如404），则使用模拟数据
     */
    public void fetchContactsFromServer() {
        Log.d(TAG, "开始从服务器获取联系人数据");
        isLoadingLiveData.postValue(true);
        errorMessageLiveData.postValue("");
        
        apiService.getContacts(new ApiService.ApiCallback<List<Contact>>() {
            @Override
            public void onSuccess(List<Contact> contacts) {

                Log.d(TAG, "成功从服务器获取联系人数据，数量: " + contacts.size());
                
                // 将数据保存到数据库
                AppDatabase.databaseWriteExecutor.execute(() -> {
                    try {
                        if (contactDao == null) {
                            reinitializeDatabase();
                            if (contactDao == null) {
                                isLoadingLiveData.postValue(false);
                                errorMessageLiveData.postValue("数据库访问错误");
                                return;
                            }
                        }
                        
                        // 清除现有的普通联系人（保留特殊联系人）
                        // 在实际应用中，应该实现更复杂的同步逻辑
                        List<Contact> specialContacts = new ArrayList<>();
                        try {
                            specialContacts = contactDao.getSpecialContactsSync();
                        } catch (Exception e) {
                            Log.e(TAG, "获取特殊联系人失败", e);
                        }
                        
                        try {
                            contactDao.deleteAll();
                        } catch (Exception e) {
                            Log.e(TAG, "清除联系人失败", e);
                            // 如果删除失败，尝试直接插入新数据
                        }
                        
                        // 重新添加特殊联系人
                        if (!specialContacts.isEmpty()) {
                            try {
                                contactDao.insertAll(specialContacts);
                            } catch (Exception e) {
                                Log.e(TAG, "添加特殊联系人失败", e);
                            }
                        }
                        
                        // 添加从服务器获取的联系人
                        try {
                            contactDao.insertAll(contacts);
                            Log.d(TAG, "联系人数据已保存到数据库");
                        } catch (Exception e) {
                            Log.e(TAG, "添加联系人失败", e);
                            errorMessageLiveData.postValue("保存联系人数据失败");
                        }
                        
                        isLoadingLiveData.postValue(false);
                    } catch (Exception e) {
                        Log.e(TAG, "保存联系人时发生错误", e);
                        isLoadingLiveData.postValue(false);
                        errorMessageLiveData.postValue("保存联系人数据时发生错误");
                    }
                });
            }
            
            @Override
            public void onFailure(ApiError error) {
                Log.e(TAG, "从服务器获取联系人数据失败: " + error.toString());
                
                // 记录错误信息
                errorMessageLiveData.postValue("获取联系人失败: " + error.getMessage());
                
                // 如果是404错误或网络错误，使用模拟数据
                if (error.getCode() == 404 || error.getCode() == 500 || error.getCode() == 0) {
                    Log.d(TAG, "使用模拟数据作为备选方案");
                    populateMockData();
                } else {
                    isLoadingLiveData.postValue(false);
                }
            }
        });
    }
    
    /**
     * Method to populate the database with mock data
     * This would be replaced with actual API calls in a real app
     */
    public void populateMockData() {
        Log.d(TAG, "使用模拟数据填充联系人");
        isLoadingLiveData.postValue(true);
        
        AppDatabase.databaseWriteExecutor.execute(() -> {
            try {
                // 确保数据库连接有效
                if (contactDao == null) {
                    reinitializeDatabase();
                    if (contactDao == null) {
                        isLoadingLiveData.postValue(false);
                        errorMessageLiveData.postValue("数据库访问错误");
                        return;
                    }
                }
                
                // 准备模拟数据
                List<Contact> contacts = createMockContacts();
                
                // 安全地清除并添加数据
                try {
                    // 尝试清除现有数据
                    contactDao.deleteAll();
                } catch (Exception e) {
                    Log.e(TAG, "清除现有联系人失败: " + e.getMessage(), e);
                    // 如果清除失败，可能是因为数据库问题，尝试重新初始化
                    reinitializeDatabase();
                    if (contactDao == null) {
                        isLoadingLiveData.postValue(false);
                        errorMessageLiveData.postValue("数据库初始化失败");
                        return;
                    }
                }
                
                try {
                    // 插入模拟数据
                    contactDao.insertAll(contacts);
                    Log.d(TAG, "模拟联系人数据已添加到数据库");
                } catch (Exception e) {
                    Log.e(TAG, "添加模拟联系人失败: " + e.getMessage(), e);
                    errorMessageLiveData.postValue("添加模拟联系人失败");
                }
                
                isLoadingLiveData.postValue(false);
            } catch (Exception e) {
                Log.e(TAG, "填充模拟数据时发生错误: " + e.getMessage(), e);
                isLoadingLiveData.postValue(false);
                errorMessageLiveData.postValue("填充模拟数据时发生错误");
            }
        });
    }
    
    /**
     * 创建模拟联系人数据
     */
    private List<Contact> createMockContacts() {
        List<Contact> contacts = new ArrayList<>();
        
        // Special contacts (like in WeChat)
        contacts.add(new Contact(Contact.TYPE_SPECIAL, "新的朋友", "new_friends_icon"));
        contacts.add(new Contact(Contact.TYPE_SPECIAL, "群聊", "group_chat_icon"));
        contacts.add(new Contact(Contact.TYPE_SPECIAL, "标签", "tags_icon"));
        contacts.add(new Contact(Contact.TYPE_SPECIAL, "公众号", "official_accounts_icon"));
        
        // Regular contacts
//
        
//        // Set some contacts as starred
//        contacts.get(5).setStarred(true);  // 孙八
//        contacts.get(11).setStarred(true); // Bob
//        contacts.get(16).setStarred(true); // Grace
        
        return contacts;
    }
    
    /**
     * 从服务器获取好友列表并保存到本地数据库
     * 这个方法会保留特殊联系人，同时替换普通联系人
     */
    public void fetchFriendsFromServer() {
        Log.d(TAG, "开始从服务器获取好友列表");
        isLoadingLiveData.postValue(true);
        errorMessageLiveData.postValue("");
        
        // 检查是否已登录
        SessionManager sessionManager = SessionManager.getInstance(application);
        if (!sessionManager.isLoggedIn()) {
            Log.e(TAG, "获取好友列表失败：用户未登录");
            isLoadingLiveData.postValue(false);
            errorMessageLiveData.postValue("用户未登录，无法获取好友列表");
            return;
        }
        
        String token = sessionManager.getAuthToken();
        if (token == null || token.isEmpty()) {
            Log.e(TAG, "获取好友列表失败：无效的认证令牌");
            isLoadingLiveData.postValue(false);
            errorMessageLiveData.postValue("无效的认证令牌");
            return;
        }
        
        // 构建API请求URL - 确保使用数字ID
        String userId = String.valueOf(sessionManager.getCurrentUserId());
        String url = apiService.getCurrentBaseUrl() + "/api/friendships/friends/" + userId;
        Log.d(TAG, "请求URL: " + url);
        
        // 创建请求
        okhttp3.Request request = new okhttp3.Request.Builder()
                .url(url)
                .header("Authorization", "Bearer " + token)
                .get()
                .build();
        
        // 执行异步请求
        apiService.getHttpClient().newCall(request).enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(okhttp3.Call call, java.io.IOException e) {
                Log.e(TAG, "获取好友列表失败: " + e.getMessage(), e);
                isLoadingLiveData.postValue(false);
                errorMessageLiveData.postValue("网络请求失败: " + e.getMessage());
            }
            
            @Override
            public void onResponse(okhttp3.Call call, okhttp3.Response response) {
                if (!response.isSuccessful()) {
                    Log.e(TAG, "获取好友列表失败: HTTP " + response.code());
                    
                    // 如果是404错误，尝试使用备用端点
                    if (response.code() == 404 || response.code() == 400) {
                        Log.d(TAG, "主端点不可用，尝试备用端点");
                        response.close(); // Close the response
                        tryFallbackEndpoint();
                        return;
                    }
                    
                    isLoadingLiveData.postValue(false);
                    errorMessageLiveData.postValue("服务器响应错误: " + response.code());
                    response.close(); // Close the response
                    return;
                }
                
                try {
                    String responseBody = response.body().string();
                    response.close(); // Close the response after reading the body
                    Log.d(TAG, "获取好友列表成功: " + responseBody);
                    
                    // 尝试不同的解析方法
                    List<Contact> friends = new ArrayList<>();
                    
                    try {
                        // 首先尝试检查响应是否包含data字段
                        org.json.JSONObject jsonObject = new JSONObject(responseBody);
                        if (jsonObject.has("data")) {
                            // 如果有data字段，从data字段中获取数据
                            Object dataObj = jsonObject.get("data");
                            if (dataObj instanceof org.json.JSONArray) {
                                // 如果data是数组，直接解析
                                org.json.JSONArray dataArray = (org.json.JSONArray) dataObj;
                                String dataArrayString = dataArray.toString();
                                friends = tryParseAsUserDTOList(dataArrayString);
                                Log.d(TAG, "从data字段解析到 " + friends.size() + " 个好友");
                            } else if (dataObj instanceof org.json.JSONObject) {
                                // 如果data是对象，尝试查找可能的数组字段
                                org.json.JSONObject dataObject = (org.json.JSONObject) dataObj;
                                String[] possibleArrayFields = {"friends", "users", "contacts", "results"};
                                
                                for (String fieldName : possibleArrayFields) {
                                    if (dataObject.has(fieldName)) {
                                        org.json.JSONArray array = dataObject.getJSONArray(fieldName);
                                        String arrayString = array.toString();
                                        friends = tryParseAsUserDTOList(arrayString);
                                        Log.d(TAG, "从data." + fieldName + "字段解析到 " + friends.size() + " 个好友");
                                        break;
                                    }
                                }
                            }
                        } else {
                            // 如果没有data字段，尝试直接解析为标准好友关系格式
                            com.google.gson.Gson gson = new com.google.gson.Gson();
                            Type listType = new TypeToken<List<Map<String, Object>>>(){}.getType();
                            List<java.util.Map<String, Object>> friendsData = gson.fromJson(responseBody, listType);
                            
                            for (Map<String, Object> friendData : friendsData) {
                                Contact contact = parseContactFromFriendship(friendData);
                                if (contact != null) {
                                    friends.add(contact);
                                }
                            }
                            
                            Log.d(TAG, "使用好友关系格式解析到 " + friends.size() + " 个好友");
                        }
                    } catch (Exception e) {
                        Log.d(TAG, "使用复杂解析方法失败，尝试直接解析为用户列表: " + e.getMessage());
                        
                        // 如果解析失败，尝试直接解析为用户列表
                        friends = tryParseAsUserDTOList(responseBody);
                        Log.d(TAG, "使用用户列表格式解析到 " + friends.size() + " 个好友");
                    }
                    
                    // 输出解析结果
                    System.out.println("所有好友为以下：" + friends);
                    
                    // 如果无法解析出好友，尝试备用端点
                    if (friends.isEmpty()) {
                        Log.d(TAG, "无法从响应中解析出好友，尝试备用端点");
                        tryFallbackEndpoint();
                        return;
                    }
                    
                    // 将数据保存到数据库
                    saveContactsToDatabase(friends);
                } catch (Exception e) {
                    Log.e(TAG, "解析好友列表数据失败: " + e.getMessage(), e);
                    isLoadingLiveData.postValue(false);
                    errorMessageLiveData.postValue("解析数据失败: " + e.getMessage());
                }
            }
        });
    }
    
    /**
     * 从好友关系数据中解析联系人信息
     * @param friendshipData 好友关系数据
     * @return 联系人对象
     */
    private Contact parseContactFromFriendship(Map<String, Object> friendshipData) {
        try {
            // 获取当前用户ID
            SessionManager sessionManager = SessionManager.getInstance(application);
            Long currentUserId = sessionManager.getCurrentUserId();
            if (currentUserId == null) {
                Log.e(TAG, "无法获取当前用户ID");
                return null;
            }

            // 从好友关系中提取好友信息
            java.util.Map<String, Object> userMap;
            System.out.println("\n\n\n\n\n\n\n\n\n-----------------------------");
            System.out.println(friendshipData+"从好友关系中提取好友信息");
//            System.out.println(friendshipData.containsKey("requester")+"  "+friendshipData.containsKey("addressee"));

            System.out.println("-----------------------------\n\n\n\n\n\n\n\n\n");
            // 检查数据格式
//            if (friendshipData.containsKey("requester") && friendshipData.containsKey("addressee")) {
//                // 标准好友关系格式
            // 安全地提取数据，处理可能的数值类型
            String userid = extractStringValue(friendshipData, "id");
            String username = extractStringValue(friendshipData, "username");
            String fullName = extractStringValue(friendshipData, "fullName");
            String email = extractStringValue(friendshipData, "email");
            String phoneNumber = extractStringValue(friendshipData, "phoneNumber");
            String gender = extractStringValue(friendshipData, "gender");
            String dateOfBirth = extractStringValue(friendshipData, "dateOfBirth");
            String updatedAt = extractStringValue(friendshipData, "updatedAt");
            String followersCount = extractStringValue(friendshipData, "followersCount");
            
            Contact contact = new Contact();
            contact.setRemark(fullName);
            contact.setName(username);
            contact.setId(userid);
            System.out.println("手动解析的数据通讯录数据结构"+contact);
            return contact;
        } catch (Exception e) {
            Log.e(TAG, "解析好友数据失败: " + e.getMessage(), e);
            return null;
        }
    }
    
    /**
     * 安全地从Map中提取字符串值
     */
    private String extractStringValue(java.util.Map<String, Object> map, String key) {
        if (map == null || !map.containsKey(key) || map.get(key) == null) {
            return null;
        }
        return map.get(key).toString();
    }
    
    /**
     * 将联系人保存到数据库
     * @param contacts 要保存的联系人列表
     */
    private void saveContactsToDatabase(List<Contact> contacts) {
        AppDatabase.databaseWriteExecutor.execute(() -> {
            try {
                if (contactDao == null) {
                    reinitializeDatabase();
                    if (contactDao == null) {
                        isLoadingLiveData.postValue(false);
                        errorMessageLiveData.postValue("数据库访问错误");
                        return;
                    }
                }
                
                // 获取现有的特殊联系人（保留这些联系人）
                List<Contact> specialContacts = new ArrayList<>();
                try {
                    specialContacts = contactDao.getSpecialContactsSync();
                } catch (Exception e) {
                    Log.e(TAG, "获取特殊联系人失败", e);
                }
                
                // 清除现有的普通联系人
                try {
                    contactDao.deleteNormalContacts();
                } catch (Exception e) {
                    Log.e(TAG, "清除普通联系人失败", e);
                }
                
                // 重新添加特殊联系人（如果没有特殊联系人，创建默认的）
                if (specialContacts.isEmpty()) {
                    specialContacts = createSpecialContacts();
                }
                
                try {
                    contactDao.insertAll(specialContacts);
                } catch (Exception e) {
                    Log.e(TAG, "添加特殊联系人失败", e);
                }
                
                // 添加从服务器获取的好友
                try {
                    contactDao.insertAll(contacts);
                    Log.d(TAG, "好友数据已保存到数据库");
                } catch (Exception e) {
                    Log.e(TAG, "添加好友失败", e);
                    errorMessageLiveData.postValue("保存好友数据失败");
                }
                
                isLoadingLiveData.postValue(false);
            } catch (Exception e) {
                Log.e(TAG, "保存好友时发生错误", e);
                isLoadingLiveData.postValue(false);
                errorMessageLiveData.postValue("保存好友数据时发生错误");
            }
        });
    }
    
    /**
     * 创建默认的特殊联系人
     */
    private List<Contact> createSpecialContacts() {
        List<Contact> specialContacts = new ArrayList<>();
        specialContacts.add(new Contact(Contact.TYPE_SPECIAL, "新的朋友", "new_friends_icon"));
        specialContacts.add(new Contact(Contact.TYPE_SPECIAL, "群聊", "group_chat_icon"));
        specialContacts.add(new Contact(Contact.TYPE_SPECIAL, "标签", "tags_icon"));
        specialContacts.add(new Contact(Contact.TYPE_SPECIAL, "公众号", "official_accounts_icon"));
        return specialContacts;
    }
    
    /**
     * 尝试使用备用端点获取好友列表
     */
    private void tryFallbackEndpoint() {
        Log.d(TAG, "尝试使用备用端点获取好友列表");
        
        // 检查认证状态
        SessionManager sessionManager = SessionManager.getInstance(application);
        if (!sessionManager.isLoggedIn()) {
            isLoadingLiveData.postValue(false);
            errorMessageLiveData.postValue("用户未登录，无法获取好友列表");
            return;
        }
        
        String token = sessionManager.getAuthToken();
        if (token == null || token.isEmpty()) {
            isLoadingLiveData.postValue(false);
            errorMessageLiveData.postValue("无效的认证令牌");
            return;
        }
        
        // 尝试不同的API端点
        String[] fallbackEndpoints = {
            "/api/friendships/friends/" + sessionManager.getCurrentUserId(),  // 确保使用数字ID而不是"current"
            "/api/friendships/accepted/" + sessionManager.getCurrentUserId(),
            "/api/users/friends/" + sessionManager.getCurrentUserId(),
            "/api/users/" + sessionManager.getCurrentUserId() + "/friends",
            "/api/friendships"  // 尝试不带参数的端点
        };
        
        // 尝试第一个备用端点
        tryNextEndpoint(fallbackEndpoints, 0, token);
    }
    
    /**
     * 递归尝试下一个API端点
     */
    private void tryNextEndpoint(String[] endpoints, int index, String token) {
        if (index >= endpoints.length) {
            // 所有端点都尝试失败，使用模拟数据
            Log.e(TAG, "所有API端点尝试失败，使用本地数据");
            isLoadingLiveData.postValue(false);
            errorMessageLiveData.postValue("无法获取好友列表，请检查网络连接");
            return;
        }
        
        String endpoint = endpoints[index];
        String url = apiService.getCurrentBaseUrl() + endpoint;
        Log.d(TAG, "尝试备用端点: " + url);
        
        // 创建请求
        okhttp3.Request request = new okhttp3.Request.Builder()
                .url(url)
                .header("Authorization", "Bearer " + token)
                .get()
                .build();
        
        // 执行异步请求
        apiService.getHttpClient().newCall(request).enqueue(new okhttp3.Callback() {
            @Override
            public void onFailure(okhttp3.Call call, java.io.IOException e) {
                Log.e(TAG, "备用端点请求失败: " + e.getMessage(), e);
                // 尝试下一个端点
                tryNextEndpoint(endpoints, index + 1, token);
            }
            
            @Override
            public void onResponse(okhttp3.Call call, okhttp3.Response response) throws java.io.IOException {
                if (!response.isSuccessful()) {
                    Log.e(TAG, "备用端点请求失败: HTTP " + response.code());
                    response.close(); // Close the response
                    
                    // 尝试下一个端点
                    tryNextEndpoint(endpoints, index + 1, token);
                    return;
                }
                
                try {
                    String responseBody = response.body().string();
                    response.close(); // Close the response after reading the body
                    Log.d(TAG, "备用端点请求成功: " + responseBody);
                    
                    // 解析响应
                    List<Contact> friends = new ArrayList<>();
                    
                    try {
                        // 首先尝试解析为标准好友关系格式
                        com.google.gson.Gson gson = new com.google.gson.Gson();
                        java.lang.reflect.Type listType = new com.google.gson.reflect.TypeToken<List<java.util.Map<String, Object>>>(){}.getType();
                        List<java.util.Map<String, Object>> friendsData = gson.fromJson(responseBody, listType);
                        
                        for (java.util.Map<String, Object> friendData : friendsData) {
                            Contact contact = parseContactFromFriendship(friendData);
                            if (contact != null) {
                                friends.add(contact);
                            }
                        }
                        
                        Log.d(TAG, "使用好友关系格式从备用端点解析到 " + friends.size() + " 个好友");
                    } catch (Exception e) {
                        Log.d(TAG, "使用好友关系格式解析备用端点失败，尝试直接解析为用户列表: " + e.getMessage());
                        
                        // 如果解析失败，尝试直接解析为用户列表
                        friends = tryParseAsUserDTOList(responseBody);
                        Log.d(TAG, "使用用户列表格式从备用端点解析到 " + friends.size() + " 个好友");
                        
                        // 如果仍然解析失败，尝试从data字段解析
                        if (friends.isEmpty()) {
                            Log.d(TAG, "使用用户列表格式解析备用端点失败，尝试从data字段解析");
                            friends = tryParseFromDataField(responseBody);
                            Log.d(TAG, "从data字段解析备用端点到 " + friends.size() + " 个好友");
                        }
                    }
                    
                    // 如果两种方法都无法解析出好友，尝试下一个端点
                    if (friends.isEmpty()) {
                        Log.d(TAG, "无法从备用端点响应中解析出好友，尝试下一个端点");
                        tryNextEndpoint(endpoints, index + 1, token);
                        return;
                    }
                    
                    // 将数据保存到数据库
                    saveContactsToDatabase(friends);
                } catch (Exception e) {
                    Log.e(TAG, "解析备用端点数据失败: " + e.getMessage(), e);
                    // 尝试下一个端点
                    tryNextEndpoint(endpoints, index + 1, token);
                }
            }
        });
    }

    /**
     * 尝试将响应解析为UserDTO对象列表
     * @param responseBody 响应体
     * @return 联系人列表
     */
    private List<Contact> tryParseAsUserDTOList(String responseBody) {
        try {
            com.google.gson.Gson gson = new com.google.gson.Gson();
            
            // 首先尝试直接解析为对象列表
            try {
                java.lang.reflect.Type listType = new com.google.gson.reflect.TypeToken<List<java.util.Map<String, Object>>>(){}.getType();
                List<java.util.Map<String, Object>> usersData = gson.fromJson(responseBody, listType);
                
                if (usersData == null) {
                    Log.e(TAG, "解析为用户列表失败：结果为null");
                    return new ArrayList<>();
                }
                
                List<Contact> contacts = new ArrayList<>();
                for (java.util.Map<String, Object> userData : usersData) {
                    // 直接从用户数据创建联系人
                    String id = extractStringValue(userData, "id");
                    String name = extractStringValue(userData, "username");
                    String fullName=extractStringValue(userData, "fullName");

                    String avatarUrl = extractStringValue(userData, "avatarUrl");
                    String avatar = "avatar_default"; // 默认头像
                    if (avatarUrl != null && !avatarUrl.isEmpty()) {
                        // 从URL中提取文件名作为资源名
                        if (avatarUrl.contains("/")) {
                            String[] parts = avatarUrl.split("/");
                            String fileName = parts[parts.length - 1];
                            // 移除文件扩展名
                            int dotIndex = fileName.lastIndexOf(".");
                            if (dotIndex > 0) {
                                fileName = fileName.substring(0, dotIndex);
                            }
                        } else {
                        }
                    }
                    
                    // 创建联系人对象
                    Contact contact = new Contact(/*id, name, avatar*/);
                    contact.setId(id);
                    contact.setName(name);
                    contact.setRemark(fullName);
                    // 设置额外信息
                    contact.setRegion(extractStringValue(userData, "region"));
                    
                    contacts.add(contact);
                }
                
                return contacts;
            } catch (Exception e) {
                Log.e(TAG, "解析为用户列表失败: " + e.getMessage(), e);
                
                // 尝试解析为单个对象
                try {
                    java.util.Map<String, Object> userData = gson.fromJson(responseBody, java.util.Map.class);
                    if (userData != null) {
                        List<Contact> contacts = new ArrayList<>();
                        
                        String id = extractStringValue(userData, "id");
                        String name = extractStringValue(userData, "fullName");
                        if (name == null || name.isEmpty()) {
                            name = extractStringValue(userData, "username");
                        }
                        
                        if (id != null && name != null) {
                            Contact contact = new Contact(id, name, "avatar_default");
                            contacts.add(contact);
                            return contacts;
                        }
                    }
                } catch (Exception e2) {
                    Log.e(TAG, "解析为单个用户对象失败: " + e2.getMessage(), e2);
                }
            }
            
            return new ArrayList<>();
        } catch (Exception e) {
            Log.e(TAG, "解析为UserDTO列表失败: " + e.getMessage(), e);
            return new ArrayList<>();
        }
    }

    /**
     * 尝试从JSON响应的data字段中解析数据
     * @param responseBody 完整的响应体
     * @return 解析后的联系人列表
     */
    private List<Contact> tryParseFromDataField(String responseBody) {
        try {
            // 尝试解析为包含data字段的JSON对象
            org.json.JSONObject jsonObject = new org.json.JSONObject(responseBody);
            
            // 检查是否有data字段
            if (!jsonObject.has("data")) {
                return new ArrayList<>();
            }
            
            // 获取data字段
            Object dataObj = jsonObject.get("data");
            
            // 如果data是数组，直接解析
            if (dataObj instanceof org.json.JSONArray) {
                org.json.JSONArray dataArray = (org.json.JSONArray) dataObj;
                String dataArrayString = dataArray.toString();
                return tryParseAsUserDTOList(dataArrayString);
            }
            
            // 如果data是对象，检查是否有嵌套的数组字段
            if (dataObj instanceof org.json.JSONObject) {
                org.json.JSONObject dataObject = (org.json.JSONObject) dataObj;
                
                // 检查常见的数组字段名
                String[] possibleArrayFields = {"friends", "users", "contacts", "results"};
                
                for (String fieldName : possibleArrayFields) {
                    if (dataObject.has(fieldName)) {
                        org.json.JSONArray array = dataObject.getJSONArray(fieldName);
                        String arrayString = array.toString();
                        return tryParseAsUserDTOList(arrayString);
                    }
                }
            }
            
            return new ArrayList<>();
        } catch (Exception e) {
            Log.e(TAG, "从data字段解析失败: " + e.getMessage(), e);
            return new ArrayList<>();
        }
    }
}